home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / swingall.jar / javax / swing / tree / DefaultTreeSelectionModel.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-07-15  |  11.7 KB  |  764 lines
  1. package javax.swing.tree;
  2.  
  3. import java.beans.PropertyChangeListener;
  4. import java.io.IOException;
  5. import java.io.ObjectInputStream;
  6. import java.io.ObjectOutputStream;
  7. import java.io.Serializable;
  8. import java.util.BitSet;
  9. import java.util.Vector;
  10. import javax.swing.DefaultListSelectionModel;
  11. import javax.swing.event.EventListenerList;
  12. import javax.swing.event.SwingPropertyChangeSupport;
  13. import javax.swing.event.TreeSelectionEvent;
  14. import javax.swing.event.TreeSelectionListener;
  15.  
  16. public class DefaultTreeSelectionModel implements Cloneable, Serializable, TreeSelectionModel {
  17.    public static final String SELECTION_MODE_PROPERTY = "selectionMode";
  18.    protected SwingPropertyChangeSupport changeSupport;
  19.    protected TreePath[] selection;
  20.    protected EventListenerList listenerList = new EventListenerList();
  21.    protected transient RowMapper rowMapper;
  22.    protected DefaultListSelectionModel listSelectionModel = new DefaultListSelectionModel();
  23.    protected int selectionMode = 4;
  24.    protected TreePath leadPath;
  25.    protected int leadIndex;
  26.    protected int leadRow;
  27.    // $FF: synthetic field
  28.    static Class class$javax$swing$event$TreeSelectionListener;
  29.  
  30.    public DefaultTreeSelectionModel() {
  31.       this.leadIndex = this.leadRow = -1;
  32.    }
  33.  
  34.    public synchronized void addPropertyChangeListener(PropertyChangeListener var1) {
  35.       if (this.changeSupport == null) {
  36.          this.changeSupport = new SwingPropertyChangeSupport(this);
  37.       }
  38.  
  39.       this.changeSupport.addPropertyChangeListener(var1);
  40.    }
  41.  
  42.    public void addSelectionPath(TreePath var1) {
  43.       if (var1 != null) {
  44.          TreePath[] var2 = new TreePath[]{var1};
  45.          this.addSelectionPaths(var2);
  46.       }
  47.  
  48.    }
  49.  
  50.    public void addSelectionPaths(TreePath[] var1) {
  51.       int var2 = var1 == null ? 0 : var1.length;
  52.       if (var2 > 0) {
  53.          if (this.selectionMode == 1 && this.selection != null && this.selection.length > 0) {
  54.             this.setSelectionPaths(var1);
  55.          } else if (this.selectionMode == 2 && !this.canPathsBeAdded(var1)) {
  56.             if (this.arePathsContiguous(var1)) {
  57.                this.setSelectionPaths(var1);
  58.             } else {
  59.                TreePath[] var13 = new TreePath[]{var1[0]};
  60.                this.setSelectionPaths(var13);
  61.             }
  62.          } else {
  63.             TreePath var9 = this.leadPath;
  64.             Vector var10 = null;
  65.             int var7;
  66.             if (this.selection == null) {
  67.                var7 = 0;
  68.             } else {
  69.                var7 = this.selection.length;
  70.             }
  71.  
  72.             boolean var3 = false;
  73.             this.leadPath = null;
  74.             int var5 = 0;
  75.  
  76.             int var6;
  77.             for(var6 = 0; var5 < var1.length; ++var5) {
  78.                if (var1[var5] != null) {
  79.                   boolean var4 = false;
  80.  
  81.                   for(int var8 = 0; var8 < var7; ++var8) {
  82.                      if (var1[var5].equals(this.selection[var8])) {
  83.                         var8 = var7;
  84.                         if (!var3) {
  85.                            TreePath[] var11 = new TreePath[var1.length];
  86.                            System.arraycopy(var1, 0, var11, 0, var1.length);
  87.                            var1 = var11;
  88.                            var3 = true;
  89.                         }
  90.  
  91.                         var1[var5] = null;
  92.                         var4 = true;
  93.                      }
  94.                   }
  95.  
  96.                   if (!var4) {
  97.                      ++var6;
  98.                      if (var10 == null) {
  99.                         var10 = new Vector();
  100.                      }
  101.  
  102.                      var10.addElement(new PathPlaceHolder(var1[var5], true));
  103.                   }
  104.  
  105.                   if (this.leadPath == null) {
  106.                      this.leadPath = var1[var5];
  107.                   }
  108.                }
  109.             }
  110.  
  111.             if (this.leadPath == null) {
  112.                this.leadPath = var9;
  113.             }
  114.  
  115.             if (var6 > 0) {
  116.                TreePath[] var15 = new TreePath[var7 + var6];
  117.                if (var7 > 0) {
  118.                   System.arraycopy(this.selection, 0, var15, 0, var7);
  119.                }
  120.  
  121.                if (var6 != var1.length) {
  122.                   int var12 = 0;
  123.  
  124.                   for(int var14 = 0; var14 < var1.length; ++var14) {
  125.                      if (var1[var14] != null) {
  126.                         var15[var7 + var12++] = var1[var14];
  127.                      }
  128.                   }
  129.                } else {
  130.                   System.arraycopy(var1, 0, var15, var7, var6);
  131.                }
  132.  
  133.                this.selection = var15;
  134.                this.insureUniqueness();
  135.                this.updateLeadIndex();
  136.                this.resetRowSelection();
  137.                this.notifyPathChange(var10, var9);
  138.             } else {
  139.                this.leadPath = var9;
  140.             }
  141.          }
  142.       }
  143.  
  144.    }
  145.  
  146.    public void addTreeSelectionListener(TreeSelectionListener var1) {
  147.       this.listenerList.add(class$javax$swing$event$TreeSelectionListener != null ? class$javax$swing$event$TreeSelectionListener : (class$javax$swing$event$TreeSelectionListener = class$("javax.swing.event.TreeSelectionListener")), var1);
  148.    }
  149.  
  150.    protected boolean arePathsContiguous(TreePath[] var1) {
  151.       if (this.rowMapper != null && var1.length >= 2) {
  152.          BitSet var2 = new BitSet(32);
  153.          int var6 = var1.length;
  154.          int var7 = 0;
  155.          TreePath[] var8 = new TreePath[]{var1[0]};
  156.          int var5 = this.rowMapper.getRowsForPaths(var8)[0];
  157.  
  158.          for(int var4 = 0; var4 < var6; ++var4) {
  159.             if (var1[var4] != null) {
  160.                var8[0] = var1[var4];
  161.                int var3 = this.rowMapper.getRowsForPaths(var8)[0];
  162.                if (var3 == -1 || var3 < var5 - var6 || var3 > var5 + var6) {
  163.                   return false;
  164.                }
  165.  
  166.                if (var3 < var5) {
  167.                   var5 = var3;
  168.                }
  169.  
  170.                if (!var2.get(var3)) {
  171.                   var2.set(var3);
  172.                   ++var7;
  173.                }
  174.             }
  175.          }
  176.  
  177.          int var9 = var7 + var5;
  178.  
  179.          for(int var10 = var5; var10 < var9; ++var10) {
  180.             if (!var2.get(var10)) {
  181.                return false;
  182.             }
  183.          }
  184.  
  185.          return true;
  186.       } else {
  187.          return true;
  188.       }
  189.    }
  190.  
  191.    protected boolean canPathsBeAdded(TreePath[] var1) {
  192.       if (var1 != null && var1.length != 0 && this.rowMapper != null && this.selection != null && this.selectionMode != 4) {
  193.          BitSet var2 = new BitSet();
  194.          DefaultListSelectionModel var3 = this.listSelectionModel;
  195.          int var6 = var3.getMinSelectionIndex();
  196.          int var7 = var3.getMaxSelectionIndex();
  197.          TreePath[] var8 = new TreePath[1];
  198.          if (var6 != -1) {
  199.             for(int var5 = var6; var5 <= var7; ++var5) {
  200.                if (var3.isSelectedIndex(var6)) {
  201.                   var2.set(var5);
  202.                }
  203.             }
  204.          } else {
  205.             var8[0] = var1[0];
  206.             var6 = var7 = this.rowMapper.getRowsForPaths(var8)[0];
  207.          }
  208.  
  209.          for(int var9 = var1.length - 1; var9 >= 0; --var9) {
  210.             if (var1[var9] != null) {
  211.                var8[0] = var1[var9];
  212.                int var4 = this.rowMapper.getRowsForPaths(var8)[0];
  213.                var6 = Math.min(var4, var6);
  214.                var7 = Math.max(var4, var7);
  215.                if (var4 == -1) {
  216.                   return false;
  217.                }
  218.  
  219.                var2.set(var4);
  220.             }
  221.          }
  222.  
  223.          for(int var10 = var6; var10 <= var7; ++var10) {
  224.             if (!var2.get(var10)) {
  225.                return false;
  226.             }
  227.          }
  228.  
  229.          return true;
  230.       } else {
  231.          return true;
  232.       }
  233.    }
  234.  
  235.    protected boolean canPathsBeRemoved(TreePath[] var1) {
  236.       if (this.rowMapper != null && this.selection != null && this.selectionMode != 4) {
  237.          BitSet var3 = new BitSet();
  238.          int var6 = var1.length;
  239.          int var8 = -1;
  240.          int var9 = 0;
  241.          TreePath[] var10 = new TreePath[var6];
  242.          TreePath[] var11 = new TreePath[1];
  243.          System.arraycopy(var1, 0, var10, 0, var6);
  244.  
  245.          for(int var4 = this.selection.length - 1; var4 >= 0; --var4) {
  246.             boolean var2 = false;
  247.  
  248.             for(int var5 = 0; var5 < var6; ++var5) {
  249.                if (var10[var5] != null && this.selection[var4].equals(var10[var5])) {
  250.                   var10[var5] = null;
  251.                   var2 = true;
  252.                   break;
  253.                }
  254.             }
  255.  
  256.             if (!var2) {
  257.                var11[0] = this.selection[var4];
  258.                int var7 = this.rowMapper.getRowsForPaths(var11)[0];
  259.                if (var7 != -1 && !var3.get(var7)) {
  260.                   ++var9;
  261.                   if (var8 == -1) {
  262.                      var8 = var7;
  263.                   } else {
  264.                      var8 = Math.min(var8, var7);
  265.                   }
  266.  
  267.                   var3.set(var7);
  268.                }
  269.             }
  270.          }
  271.  
  272.          if (var9 > 1) {
  273.             for(int var12 = var8 + var9 - 1; var12 >= var8; --var12) {
  274.                if (!var3.get(var12)) {
  275.                   return false;
  276.                }
  277.             }
  278.          }
  279.  
  280.          return true;
  281.       } else {
  282.          return true;
  283.       }
  284.    }
  285.  
  286.    // $FF: synthetic method
  287.    static Class class$(String var0) {
  288.       try {
  289.          return Class.forName(var0);
  290.       } catch (ClassNotFoundException var2) {
  291.          throw new NoClassDefFoundError(((Throwable)var2).getMessage());
  292.       }
  293.    }
  294.  
  295.    public void clearSelection() {
  296.       if (this.selection != null) {
  297.          int var1 = this.selection.length;
  298.          boolean[] var2 = new boolean[var1];
  299.  
  300.          for(int var3 = 0; var3 < var1; ++var3) {
  301.             var2[var3] = false;
  302.          }
  303.  
  304.          TreeSelectionEvent var4 = new TreeSelectionEvent(this, this.selection, var2, this.leadPath, (TreePath)null);
  305.          this.leadPath = null;
  306.          this.leadIndex = this.leadRow = -1;
  307.          this.selection = null;
  308.          this.resetRowSelection();
  309.          this.fireValueChanged(var4);
  310.       }
  311.  
  312.    }
  313.  
  314.    public Object clone() throws CloneNotSupportedException {
  315.       DefaultTreeSelectionModel var1 = (DefaultTreeSelectionModel)super.clone();
  316.       var1.changeSupport = null;
  317.       if (this.selection != null) {
  318.          int var2 = this.selection.length;
  319.          var1.selection = new TreePath[var2];
  320.          System.arraycopy(this.selection, 0, var1.selection, 0, var2);
  321.       }
  322.  
  323.       var1.listenerList = new EventListenerList();
  324.       var1.listSelectionModel = (DefaultListSelectionModel)this.listSelectionModel.clone();
  325.       return var1;
  326.    }
  327.  
  328.    protected void fireValueChanged(TreeSelectionEvent var1) {
  329.       Object[] var2 = this.listenerList.getListenerList();
  330.  
  331.       for(int var3 = var2.length - 2; var3 >= 0; var3 -= 2) {
  332.          if (var2[var3] == (class$javax$swing$event$TreeSelectionListener != null ? class$javax$swing$event$TreeSelectionListener : (class$javax$swing$event$TreeSelectionListener = class$("javax.swing.event.TreeSelectionListener")))) {
  333.             ((TreeSelectionListener)var2[var3 + 1]).valueChanged(var1);
  334.          }
  335.       }
  336.  
  337.    }
  338.  
  339.    public TreePath getLeadSelectionPath() {
  340.       return this.leadPath;
  341.    }
  342.  
  343.    public int getLeadSelectionRow() {
  344.       return this.leadRow;
  345.    }
  346.  
  347.    public int getMaxSelectionRow() {
  348.       return this.listSelectionModel.getMaxSelectionIndex();
  349.    }
  350.  
  351.    public int getMinSelectionRow() {
  352.       return this.listSelectionModel.getMinSelectionIndex();
  353.    }
  354.  
  355.    public RowMapper getRowMapper() {
  356.       return this.rowMapper;
  357.    }
  358.  
  359.    public int getSelectionCount() {
  360.       return this.selection == null ? 0 : this.selection.length;
  361.    }
  362.  
  363.    public int getSelectionMode() {
  364.       return this.selectionMode;
  365.    }
  366.  
  367.    public TreePath getSelectionPath() {
  368.       return this.selection != null ? this.selection[0] : null;
  369.    }
  370.  
  371.    public TreePath[] getSelectionPaths() {
  372.       if (this.selection != null) {
  373.          int var1 = this.selection.length;
  374.          TreePath[] var2 = new TreePath[var1];
  375.          System.arraycopy(this.selection, 0, var2, 0, var1);
  376.          return var2;
  377.       } else {
  378.          return null;
  379.       }
  380.    }
  381.  
  382.    public int[] getSelectionRows() {
  383.       return this.rowMapper != null && this.selection != null ? this.rowMapper.getRowsForPaths(this.selection) : null;
  384.    }
  385.  
  386.    protected void insureRowContinuity() {
  387.       if (this.selectionMode == 2 && this.selection != null && this.rowMapper != null) {
  388.          DefaultListSelectionModel var1 = this.listSelectionModel;
  389.          int var2 = var1.getMinSelectionIndex();
  390.          if (var2 != -1) {
  391.             int var3 = var2;
  392.  
  393.             for(int var4 = var1.getMaxSelectionIndex(); var3 <= var4; ++var3) {
  394.                if (!var1.isSelectedIndex(var3)) {
  395.                   if (var3 != var2) {
  396.                      TreePath[] var5 = new TreePath[var3 - var2];
  397.                      System.arraycopy(this.selection, 0, var5, 0, var3 - var2);
  398.                      this.setSelectionPaths(var5);
  399.                      break;
  400.                   }
  401.  
  402.                   this.clearSelection();
  403.                }
  404.             }
  405.          }
  406.       } else if (this.selectionMode == 1 && this.selection != null && this.selection.length > 1) {
  407.          this.setSelectionPath(this.selection[0]);
  408.       }
  409.  
  410.    }
  411.  
  412.    protected void insureUniqueness() {
  413.       int var2 = 0;
  414.  
  415.       for(int var1 = 0; var1 < this.selection.length; ++var1) {
  416.          if (this.selection[var1] != null) {
  417.             for(int var3 = var1 + 1; var3 < this.selection.length; ++var3) {
  418.                if (this.selection[var3] != null && this.selection[var1].equals(this.selection[var3])) {
  419.                   ++var2;
  420.                   this.selection[var3] = null;
  421.                }
  422.             }
  423.          }
  424.       }
  425.  
  426.       if (var2 > 0) {
  427.          TreePath[] var4 = new TreePath[this.selection.length - var2];
  428.          int var5 = 0;
  429.  
  430.          for(int var6 = 0; var5 < this.selection.length; ++var5) {
  431.             if (this.selection[var5] != null) {
  432.                var4[var6++] = this.selection[var5];
  433.             }
  434.          }
  435.  
  436.          this.selection = var4;
  437.       }
  438.  
  439.    }
  440.  
  441.    public boolean isPathSelected(TreePath var1) {
  442.       if (this.selection != null) {
  443.          for(int var2 = 0; var2 < this.selection.length; ++var2) {
  444.             if (this.selection[var2].equals(var1)) {
  445.                return true;
  446.             }
  447.          }
  448.       }
  449.  
  450.       return false;
  451.    }
  452.  
  453.    public boolean isRowSelected(int var1) {
  454.       return this.listSelectionModel.isSelectedIndex(var1);
  455.    }
  456.  
  457.    public boolean isSelectionEmpty() {
  458.       return this.selection == null;
  459.    }
  460.  
  461.    protected void notifyPathChange(Vector var1, TreePath var2) {
  462.       int var3 = var1.size();
  463.       boolean[] var4 = new boolean[var3];
  464.       TreePath[] var5 = new TreePath[var3];
  465.  
  466.       for(int var7 = 0; var7 < var3; ++var7) {
  467.          PathPlaceHolder var6 = (PathPlaceHolder)var1.elementAt(var7);
  468.          var4[var7] = var6.isNew;
  469.          var5[var7] = var6.path;
  470.       }
  471.  
  472.       TreeSelectionEvent var8 = new TreeSelectionEvent(this, var5, var4, var2, this.leadPath);
  473.       this.fireValueChanged(var8);
  474.    }
  475.  
  476.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  477.       var1.defaultReadObject();
  478.       Object[] var2 = var1.readObject();
  479.       if (var2.length > 0 && var2[0].equals("rowMapper")) {
  480.          this.rowMapper = (RowMapper)var2[1];
  481.       }
  482.  
  483.    }
  484.  
  485.    public synchronized void removePropertyChangeListener(PropertyChangeListener var1) {
  486.       if (this.changeSupport != null) {
  487.          this.changeSupport.removePropertyChangeListener(var1);
  488.       }
  489.    }
  490.  
  491.    public void removeSelectionPath(TreePath var1) {
  492.       if (var1 != null) {
  493.          TreePath[] var2 = new TreePath[]{var1};
  494.          this.removeSelectionPaths(var2);
  495.       }
  496.  
  497.    }
  498.  
  499.    public void removeSelectionPaths(TreePath[] var1) {
  500.       if (var1 != null && this.selection != null && var1.length > 0) {
  501.          if (!this.canPathsBeRemoved(var1)) {
  502.             this.clearSelection();
  503.          } else {
  504.             boolean var6 = false;
  505.             TreePath var7 = this.leadPath;
  506.             Vector var8 = null;
  507.             int var2 = this.selection.length;
  508.  
  509.             for(int var5 = 0; var5 < var1.length; ++var5) {
  510.                if (var1[var5] != null) {
  511.                   if (this.leadPath != null && this.leadPath.equals(var1[var5])) {
  512.                      this.leadPath = null;
  513.                   }
  514.  
  515.                   for(int var3 = 0; var3 < var2; ++var3) {
  516.                      if (var1[var5].equals(this.selection[var3])) {
  517.                         this.selection[var3] = null;
  518.                         var3 = var2;
  519.                         if (var8 == null) {
  520.                            var8 = new Vector(var1.length);
  521.                         }
  522.  
  523.                         if (!var8.contains(var1[var5])) {
  524.                            var8.addElement(new PathPlaceHolder(var1[var5], false));
  525.                         }
  526.                      }
  527.                   }
  528.                }
  529.             }
  530.  
  531.             if (var8 != null) {
  532.                int var4 = var8.size();
  533.                if (var4 == this.selection.length) {
  534.                   this.selection = null;
  535.                } else {
  536.                   int var9 = 0;
  537.                   TreePath[] var10 = new TreePath[this.selection.length - var4];
  538.  
  539.                   for(int var11 = 0; var11 < var2; ++var11) {
  540.                      if (this.selection[var11] != null) {
  541.                         var10[var9++] = this.selection[var11];
  542.                      }
  543.                   }
  544.  
  545.                   this.selection = var10;
  546.                }
  547.  
  548.                if (this.leadPath == null && this.selection != null) {
  549.                   this.leadPath = this.selection[0];
  550.                }
  551.  
  552.                this.updateLeadIndex();
  553.                this.resetRowSelection();
  554.                this.notifyPathChange(var8, var7);
  555.             }
  556.          }
  557.       }
  558.  
  559.    }
  560.  
  561.    public void removeTreeSelectionListener(TreeSelectionListener var1) {
  562.       this.listenerList.remove(class$javax$swing$event$TreeSelectionListener != null ? class$javax$swing$event$TreeSelectionListener : (class$javax$swing$event$TreeSelectionListener = class$("javax.swing.event.TreeSelectionListener")), var1);
  563.    }
  564.  
  565.    public void resetRowSelection() {
  566.       this.listSelectionModel.clearSelection();
  567.       if (this.selection != null && this.rowMapper != null) {
  568.          boolean var2 = false;
  569.          int[] var3 = this.rowMapper.getRowsForPaths(this.selection);
  570.          int var4 = 0;
  571.  
  572.          for(int var5 = this.selection.length; var4 < var5; ++var4) {
  573.             int var1 = var3[var4];
  574.             if (var1 != -1) {
  575.                this.listSelectionModel.addSelectionInterval(var1, var1);
  576.             }
  577.          }
  578.  
  579.          if (this.leadIndex != -1) {
  580.             this.leadRow = var3[this.leadIndex];
  581.          }
  582.  
  583.          this.insureRowContinuity();
  584.       } else {
  585.          this.leadRow = -1;
  586.       }
  587.  
  588.    }
  589.  
  590.    public void setRowMapper(RowMapper var1) {
  591.       this.rowMapper = var1;
  592.       this.resetRowSelection();
  593.    }
  594.  
  595.    public void setSelectionMode(int var1) {
  596.       int var2 = this.selectionMode;
  597.       this.selectionMode = var1;
  598.       if (this.selectionMode != 1 && this.selectionMode != 2 && this.selectionMode != 4) {
  599.          this.selectionMode = 4;
  600.       }
  601.  
  602.       if (var2 != this.selectionMode && this.changeSupport != null) {
  603.          this.changeSupport.firePropertyChange("selectionMode", new Integer(var2), new Integer(this.selectionMode));
  604.       }
  605.  
  606.    }
  607.  
  608.    public void setSelectionPath(TreePath var1) {
  609.       if (var1 == null) {
  610.          this.setSelectionPaths((TreePath[])null);
  611.       } else {
  612.          TreePath[] var2 = new TreePath[]{var1};
  613.          this.setSelectionPaths(var2);
  614.       }
  615.  
  616.    }
  617.  
  618.    public void setSelectionPaths(TreePath[] var1) {
  619.       boolean var2 = false;
  620.       TreePath[] var7 = var1;
  621.       int var3;
  622.       if (var1 == null) {
  623.          var3 = 0;
  624.       } else {
  625.          var3 = var1.length;
  626.       }
  627.  
  628.       int var5;
  629.       if (this.selection == null) {
  630.          var5 = 0;
  631.       } else {
  632.          var5 = this.selection.length;
  633.       }
  634.  
  635.       if (var3 + var5 != 0) {
  636.          if (this.selectionMode == 1) {
  637.             if (var3 > 1) {
  638.                var7 = new TreePath[]{var1[0]};
  639.                var3 = 1;
  640.             }
  641.          } else if (this.selectionMode == 2 && var3 > 0 && !this.arePathsContiguous(var1)) {
  642.             var7 = new TreePath[]{var1[0]};
  643.             var3 = 1;
  644.          }
  645.  
  646.          int var9 = 0;
  647.          TreePath var10 = this.leadPath;
  648.          Vector var11 = new Vector(var3 + var5);
  649.          this.leadPath = null;
  650.  
  651.          for(int var4 = 0; var4 < var3; ++var4) {
  652.             boolean var8 = false;
  653.             if (var7[var4] != null) {
  654.                ++var9;
  655.  
  656.                for(int var6 = 0; var6 < var5; ++var6) {
  657.                   if (this.selection[var6] != null && this.selection[var6].equals(var7[var4])) {
  658.                      this.selection[var6] = null;
  659.                      var6 = var5;
  660.                      var8 = true;
  661.                   }
  662.                }
  663.  
  664.                if (!var8) {
  665.                   var11.addElement(new PathPlaceHolder(var7[var4], true));
  666.                }
  667.  
  668.                if (this.leadPath == null) {
  669.                   this.leadPath = var7[var4];
  670.                }
  671.             }
  672.          }
  673.  
  674.          for(int var13 = 0; var13 < var5; ++var13) {
  675.             if (this.selection[var13] != null) {
  676.                var11.addElement(new PathPlaceHolder(this.selection[var13], false));
  677.             }
  678.          }
  679.  
  680.          if (var9 == 0) {
  681.             this.selection = null;
  682.          } else if (var9 != var3) {
  683.             this.selection = new TreePath[var9];
  684.             int var12 = 0;
  685.  
  686.             for(int var14 = 0; var12 < var3; ++var12) {
  687.                if (var7[var12] != null) {
  688.                   this.selection[var14++] = var7[var12];
  689.                }
  690.             }
  691.          } else {
  692.             this.selection = new TreePath[var7.length];
  693.             System.arraycopy(var7, 0, this.selection, 0, var7.length);
  694.          }
  695.  
  696.          if (this.selection != null) {
  697.             this.insureUniqueness();
  698.          }
  699.  
  700.          this.updateLeadIndex();
  701.          this.resetRowSelection();
  702.          if (var11.size() > 0) {
  703.             this.notifyPathChange(var11, var10);
  704.          }
  705.       }
  706.  
  707.    }
  708.  
  709.    public String toString() {
  710.       int var1 = this.getSelectionCount();
  711.       StringBuffer var2 = new StringBuffer();
  712.       int[] var3;
  713.       if (this.rowMapper != null) {
  714.          var3 = this.rowMapper.getRowsForPaths(this.selection);
  715.       } else {
  716.          var3 = null;
  717.       }
  718.  
  719.       var2.append(this.getClass().getName() + " " + this.hashCode() + " [ ");
  720.  
  721.       for(int var4 = 0; var4 < var1; ++var4) {
  722.          if (var3 != null) {
  723.             var2.append(this.selection[var4].toString() + "@" + Integer.toString(var3[var4]) + " ");
  724.          } else {
  725.             var2.append(this.selection[var4].toString() + " ");
  726.          }
  727.       }
  728.  
  729.       var2.append("]");
  730.       return var2.toString();
  731.    }
  732.  
  733.    protected void updateLeadIndex() {
  734.       if (this.leadPath != null) {
  735.          if (this.selection == null) {
  736.             this.leadPath = null;
  737.             this.leadIndex = this.leadRow = -1;
  738.          } else {
  739.             this.leadRow = this.leadIndex = -1;
  740.  
  741.             for(int var1 = this.selection.length - 1; var1 >= 0; --var1) {
  742.                if (this.selection[var1].equals(this.leadPath)) {
  743.                   this.leadIndex = var1;
  744.                   break;
  745.                }
  746.             }
  747.          }
  748.       }
  749.  
  750.    }
  751.  
  752.    private void writeObject(ObjectOutputStream var1) throws IOException {
  753.       var1.defaultWriteObject();
  754.       Object[] var2;
  755.       if (this.rowMapper != null && this.rowMapper instanceof Serializable) {
  756.          var2 = new Object[]{"rowMapper", this.rowMapper};
  757.       } else {
  758.          var2 = new Object[0];
  759.       }
  760.  
  761.       var1.writeObject(var2);
  762.    }
  763. }
  764.